/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_Studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#pragma once

#include <file_文件名数据.h>

#include "节点/节点.h"

#include "节点/插座/C_物体插座.h"
#include "节点/插座/list/list矢量插座.h"


class API_EXPORT C_物体节点 : public C_节点基类 {
public:
	C_物体节点(S_设备环境& ctx);
	~C_物体节点();

	S_Props	m_物体类型;
	S_Props	m_物体显示模式;
	S_Props	m_物体名称;
	//S_Props	m_物体边框显示;

	bool			f_update();
	S_动画曲线组*	f_getAN曲线();
	void			f_Show(bool open);
	void			f_删除();
	void    f_读取(FILE* f);
	void    f_写入(FILE* f);
};

C_节点基类* f_node_创建物体节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载物体节点(S_设备环境& ctx, FILE* f);
void f_node_保存物体节点(C_节点基类* n, FILE* f);


class API_EXPORT C_取物体节点 : public C_节点基类 {
	S_动画曲线组* m_动画曲线列表;
public:
	C_取物体节点(S_设备环境& ctx);
	~C_取物体节点();

	S_Props	m_过滤类型;
	bool	f_update();
	S_动画曲线组* f_getAN曲线();
	uint32        f_getAN曲线数量(){return m_动画曲线列表->通道num;}
	void    f_读取(FILE* f);
	void    f_写入(FILE* f);
};

C_节点基类* f_node_创建取物体节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载取物体节点(S_设备环境& ctx, FILE* f);
void f_node_保存取物体节点(C_节点基类* n, FILE* f);



class API_EXPORT C_设置物体渲染属性节点 : public C_节点基类 {
	S_动画曲线组* m_动画曲线列表;
public:
	C_设置物体渲染属性节点(S_设备环境& ctx);
	~C_设置物体渲染属性节点();

	S_Props	m_可渲染;
	S_Props	m_灯光通道;

	bool	f_update();
	S_动画曲线组* f_getAN曲线();
	uint32        f_getAN曲线数量() { return m_动画曲线列表->通道num; }
	void    f_读取(FILE* f);
	void    f_写入(FILE* f);
};

C_节点基类* f_node_创建设置物体渲染属性节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载设置物体渲染属性节点(S_设备环境& ctx, FILE* f);
void		f_node_保存设置物体渲染属性节点(C_节点基类* n, FILE* f);



class API_EXPORT C_查找子物体节点 : public C_节点基类 {
	S_动画曲线组* m_动画曲线列表;
public:
	C_查找子物体节点(S_设备环境& ctx);
	~C_查找子物体节点();

	S_Props	m_查找类型;
	bool	f_update();
	S_动画曲线组* f_getAN曲线();
	uint32        f_getAN曲线数量(){return m_动画曲线列表->通道num;}
	void    f_读取(FILE* f);
	void    f_写入(FILE* f);
};

C_节点基类* f_node_创建查找子物体节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载查找子物体节点(S_设备环境& ctx, FILE* f);
void        f_node_保存查找子物体节点(C_节点基类* n, FILE* f);



class API_EXPORT C_引用物体节点 : public C_节点基类 {
	std::u16string m_name;
public:
	C_引用物体节点(S_设备环境& ctx);
	~C_引用物体节点();

	S_Props m_引用查找方式;
	S_Props m_查找名称;
	S_Props m_物体名称;

	bool	      f_update();
	S_动画曲线组* f_getAN曲线();
	void    f_读取(FILE* f);
	void    f_写入(FILE* f);
};

C_节点基类* f_node_创建引用物体节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载引用物体节点(S_设备环境& ctx, FILE* f);
void f_node_保存引用物体节点(C_节点基类* n, FILE* f);




class API_EXPORT C_物体虚拟体节点 : public C_节点基类 {
	S_物体*       m_Ob;
	S_动画曲线组* m_动画曲线列表;

public:
	C_物体虚拟体节点(S_设备环境& ctx);
	~C_物体虚拟体节点();

	S_Props m_虚拟体网格类型;
	//S_Props m_虚拟体网格大小;

	bool	      f_update();
	S_动画曲线组* f_getAN曲线();
	uint32        f_getAN曲线数量(){return m_动画曲线列表->通道num;}
	S_物体* f_虚拟体();
	void	f_删除();
	void	f_回收();

	void    f_读取(FILE* f);
	void    f_写入(FILE* f);
};

C_节点基类* f_node_创建物体虚拟体节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载物体虚拟体节点(S_设备环境& ctx, FILE* f);
void f_node_保存物体虚拟体节点(C_节点基类* n, FILE* f);




class API_EXPORT C_天空节点 : public C_节点基类 {
	S_物体* m_Ob;
	S_动画曲线组* m_动画曲线列表;

public:
	C_天空节点(S_设备环境& ctx);
	~C_天空节点();

	S_Props m_天空类型;
	S_Props m_天空大小;
	S_Props m_亮度;
	//S_Props m_时间;

	bool	f_update();
	S_物体* f_虚拟体();
	void	f_删除();
	void	f_回收();

	void    f_读取(FILE* f);
	void    f_写入(FILE* f);
};

C_节点基类* f_node_创建天空节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载天空节点(S_设备环境& ctx, FILE* f);
void f_node_保存天空节点(C_节点基类* n, FILE* f);




class API_EXPORT C_物体父子关系节点 : public C_节点基类 {
public:
	C_物体父子关系节点(S_设备环境& ctx);
	~C_物体父子关系节点();

	S_Props m_父子变换关系类型;

	bool	f_update();

	void    f_读取(FILE* f);
	void    f_写入(FILE* f);
};

C_节点基类* f_node_创建物体父子关系节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载物体父子关系节点(S_设备环境& ctx, FILE* f);
void f_node_保存物体父子关系节点(C_节点基类* n, FILE* f);



class API_EXPORT C_设置物体数据节点 : public C_节点基类 {
public:
	C_设置物体数据节点(S_设备环境& ctx);
	~C_设置物体数据节点();

	bool	f_update();

	S_物体* f_虚拟体();
	void	f_删除();
	void	f_回收();
};

C_节点基类* f_node_加载设置物体数据节点(S_设备环境& ctx, FILE* f);
void f_node_保存设置物体数据节点(C_节点基类* n, FILE* f);



class API_EXPORT C_取物体属性节点 : public C_节点基类 {
public:
	C_取物体属性节点(S_设备环境& ctx);
	~C_取物体属性节点();

	bool	f_update();
};

C_节点基类* f_node_加载取物体属性节点(S_设备环境& ctx, FILE* f);
void f_node_保存取物体属性节点(C_节点基类* n, FILE* f);





class API_EXPORT C_多边形物体节点 : public C_节点基类 {
	S_OBArray* m_缓存物体组;
public:
	C_多边形物体节点(S_设备环境& ctx);
	~C_多边形物体节点();

	bool	f_update();
};

C_节点基类* f_node_创建多边形物体节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载多边形物体节点(S_设备环境& ctx, FILE* f);
void        f_node_保存多边形物体节点(C_节点基类* n, FILE* f);



class API_EXPORT C_骨头节点 : public C_节点基类 {
	S_物体* m_骨头物体;
	S_物体* m_末端骨节;
	
	S_物体* m_封套;
public:
	C_骨头节点(S_设备环境& ctx);
	~C_骨头节点();

	S_Props	m_封套长度;

	S_Props	m_封套S内半径;
	S_Props	m_封套E内半径;

	S_Props	m_封套S外半径;
	S_Props	m_封套E外半径;

	S_Props	m_自动封套大小;

	bool	f_update();

	S_物体* f_虚拟体();
	void	f_删除();
	void	f_回收();
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建骨头节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载骨头节点(S_设备环境& ctx, FILE* f);
void		f_node_保存骨头节点(C_节点基类* n, FILE* f);




class API_EXPORT C_骨架节点 : public C_节点基类 {
	S_物体* m_骨架;

	//std::vector<S_物体*> m_删除的根骨头;
	std::map<S_物体*, S_物体*> m_删除的根骨头;
	S_物体* m_编辑骨节物体;
	//S_物体* m_骨节物体;
	//S_物体* m_骨骼父物体;
	S_物体* m_虚线;
public:
	C_骨架节点(S_设备环境& ctx);
	~C_骨架节点();

	S_Props	m_前端显示;

	bool	f_update();
	//void	f_构建骨骼(S_物体* m_根骨骼);

	S_物体* f_虚拟体();
	void	f_删除();
	void	f_回收();
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};
C_节点基类* f_node_创建骨骼节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类*	f_node_加载骨骼节点(S_设备环境& ctx, FILE* f);
void		f_node_保存骨骼节点(C_节点基类* n, FILE* f);



class API_EXPORT C_骨骼IK节点 : public C_节点基类 {
	S_物体* m_虚拟体;
	
public:
	C_骨骼IK节点(S_设备环境& ctx);
	~C_骨骼IK节点();

	S_骨骼IK* m_Value;
	S_Props		m_迭代次数;
	S_Props		m_节数;
	S_Props		m_虚拟体类型;
	S_Props		m_坐标偏移;
	S_Props		m_使用骨节;
	bool	f_update();

	S_物体* f_虚拟体();
	void	f_删除();
	void	f_回收();
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};
C_节点基类* f_node_创建骨骼IK节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载骨骼IK节点(S_设备环境& ctx, FILE* f);
void		f_node_保存骨骼IK节点(C_节点基类* n, FILE* f);




class API_EXPORT C_虚拟空物体节点 : public C_节点基类 {
	S_物体* m_虚拟体;

public:
	C_虚拟空物体节点(S_设备环境& ctx);
	~C_虚拟空物体节点();

	S_Props		m_虚拟体类型;

	bool	f_update();

	S_物体* f_虚拟体();
	void	f_删除();
	void	f_回收();
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};
C_节点基类* f_node_创建虚拟空物体节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载虚拟空物体节点(S_设备环境& ctx, FILE* f);
void		f_node_保存虚拟空物体节点(C_节点基类* n, FILE* f);


class API_EXPORT C_物体绑定骨骼节点 : public C_节点基类 {
	S_物体* m_虚拟体;

public:
	C_物体绑定骨骼节点(S_设备环境& ctx);
	~C_物体绑定骨骼节点();

	bool	f_update();

	/*S_物体* f_get虚拟体();
	void	f_入回收();
	void	f_回收();
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);*/
};

C_节点基类* f_node_加载物体绑定骨骼节点(S_设备环境& ctx, FILE* f);
void		f_node_保存物体绑定骨骼节点(C_节点基类* n, FILE* f);



class API_EXPORT C_摄像机节点 : public C_节点基类 {
	S_物体* m_Ob;
	S_摄像机* m_摄像机;
	S_动画曲线组* m_动画曲线列表;
public:
	C_摄像机节点(S_设备环境& ctx);
	~C_摄像机节点();

	bool	      f_update();
	std::string   DEF_节点编译函数;
	S_动画曲线组* f_getAN曲线();
	uint32        f_getAN曲线数量(){return m_动画曲线列表->通道num;}

	S_物体* f_虚拟体();
	void	f_删除();
	void	f_回收();
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建摄像机节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载摄像机节点(S_设备环境& ctx, FILE* f);
void f_node_保存摄像机节点(C_节点基类* n, FILE* f);



class API_EXPORT C_目标摄像机节点 : public C_节点基类 {
	S_物体* m_Ob;
	S_物体* m_目标;
	S_摄像机* m_摄像机;
	S_动画曲线组* m_动画曲线列表;
public:
	C_目标摄像机节点(S_设备环境& ctx);
	~C_目标摄像机节点();

	bool f_update();
	void f_异步解算();
	//std::string   DEF_节点编译函数;
	//S_动画曲线组* f_getAN曲线();
	//uint32        f_getAN曲线数量() { return m_动画曲线列表->通道num; }

	S_物体* f_虚拟体();
	void	f_删除();
	void	f_回收();
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建目标摄像机节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载目标摄像机节点(S_设备环境& ctx, FILE* f);
void        f_node_保存目标摄像机节点(C_节点基类* n, FILE* f);



class API_EXPORT C_物体拷贝节点 : public C_节点基类 {
	S_设备环境	m_GPU环境;
	S_物体* m_当前拷贝物体根物体;

public:
	C_物体拷贝节点(S_设备环境& ctx);
	~C_物体拷贝节点();

	S_Props m_是否实例;

	bool	f_update();

	S_物体* f_虚拟体();
	void	f_删除();
	void	f_回收();
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};
C_节点基类* f_node_创建物体拷贝节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载物体拷贝节点(S_设备环境& ctx, FILE* f);
void        f_node_保存物体拷贝节点(C_节点基类* n, FILE* f);



class API_EXPORT C_创建物体实例节点 : public C_节点基类 {
	S_设备环境	m_GPU环境;
public:
	C_创建物体实例节点(S_设备环境& ctx);
	~C_创建物体实例节点();

	S_Props m_实例方式;
	S_Props m_开启实例材质;

	bool	f_update();

	S_物体* f_虚拟体();
	void	f_删除();
	void	f_回收();
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};
C_节点基类* f_node_创建创建物体实例节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载创建物体实例节点(S_设备环境& ctx, FILE* f);
void        f_node_保存创建物体实例节点(C_节点基类* n, FILE* f);




class API_EXPORT C_设置物体矩阵节点 : public C_节点基类 {
public:
	C_设置物体矩阵节点(S_设备环境& ctx);
	~C_设置物体矩阵节点();

	S_Props m_设置方式;

	bool	f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};
C_节点基类* f_node_创建设置物体矩阵节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载设置物体矩阵节点(S_设备环境& ctx, FILE* f);
void f_node_保存设置物体矩阵节点(C_节点基类* n, FILE* f);



class API_EXPORT C_取物体矩阵节点 : public C_节点基类 {
public:
	C_取物体矩阵节点(S_设备环境& ctx);
	~C_取物体矩阵节点();

	bool	f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};
C_节点基类* f_node_创建取物体矩阵节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载取物体矩阵节点(S_设备环境& ctx, FILE* f);
void f_node_保存取物体矩阵节点(C_节点基类* n, FILE* f);




class API_EXPORT C_设置物体变换节点 : public C_节点基类 {
	
public:
	C_设置物体变换节点(S_设备环境& ctx);
	~C_设置物体变换节点();

	S_Props m_物体模式;
	S_Props m_变换方式;

	bool	f_update();
	void	f_物体变换(S_物体* ob, const vec3& loc, const vec3& rot, const vec3& scal, uint32 offset);

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建设置物体变换节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载设置物体变换节点(S_设备环境& ctx, FILE* f);
void f_node_保存设置物体变换节点(C_节点基类* n, FILE* f);



class API_EXPORT C_取物体变换节点 : public C_节点基类 {
	//S_OBArray* m_缓存物体组;
	//bool m_数据是否以缓存;
public:
	C_取物体变换节点(S_设备环境& ctx);
	~C_取物体变换节点();

	bool	f_update();
	void	f_释放缓存();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建取物体变换节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载取物体变换节点(S_设备环境& ctx, FILE* f);
void f_node_保存取物体变换节点(C_节点基类* n, FILE* f);



class API_EXPORT C_设置物体绕轴旋转节点 : public C_节点基类 {
	//S_OBArray* m_缓存物体组;
public:
	C_设置物体绕轴旋转节点(S_设备环境& ctx);
	~C_设置物体绕轴旋转节点();

	S_Props m_中心类型;

	bool	f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建设置物体绕轴旋转节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载设置物体绕轴旋转节点(S_设备环境& ctx, FILE* f);
void		f_node_保存设置物体绕轴旋转节点(C_节点基类* n, FILE* f);



class API_EXPORT C_设置物体缩放节点 : public C_节点基类 {
	//S_OBArray* m_缓存物体组;
public:
	C_设置物体缩放节点(S_设备环境& ctx);
	~C_设置物体缩放节点();

	S_Props m_中心类型;

	bool	f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建设置物体缩放节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载设置物体缩放节点(S_设备环境& ctx, FILE* f);
void		f_node_保存设置物体缩放节点(C_节点基类* n, FILE* f);



class API_EXPORT C_物体变换节点 : public C_节点基类 {
	//S_OBArray* m_缓存物体组;
public:
	C_物体变换节点(S_设备环境& ctx);
	~C_物体变换节点();

	S_Props m_中心类型;

	bool	f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建物体变换节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载物体变换节点(S_设备环境& ctx, FILE* f);
void		f_node_保存物体变换节点(C_节点基类* n, FILE* f);



class API_EXPORT C_设置摄像机属性节点 : public C_节点基类 {
public:
	C_设置摄像机属性节点(S_设备环境& ctx);
	~C_设置摄像机属性节点();
	//S_Props m_视点距离;
	bool	f_update();
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建设置摄像机属性节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载设置摄像机属性节点(S_设备环境& ctx, FILE* f);
void        f_node_保存设置摄像机属性节点(C_节点基类* n, FILE* f);





class API_EXPORT C_外部加载物体节点 : public C_节点基类 {
	std::string m_上一次加载路径;
	//S_物体* m_Ob;
	std::vector<S_物体*> m_ObPtr;

	std::vector<S_Tranform> m_变换组;
public:
	C_外部加载物体节点(S_设备环境& ctx);
	~C_外部加载物体节点();

	S_Props m_是否递归目录;
	S_Props m_是否序列;
	S_Props m_Path;
	S_Props m_文件类型;
	S_Props m_瓦片;
	S_Props	m_网格类型;

	S_Props	m_预缩放;
	S_Props m_平滑法线;

	S_Props		m_位置;
	S_Props		m_旋转;
	S_Props		m_缩放;

	S_Props	m_应用变换;

	bool		m_重写加载;
	//std::string	DEF_节点编译函数;

	bool	f_update();
	void	f_递归加载物体(std::string path);
	void	f_加载物体(std::string path);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
	S_物体* f_虚拟体();
	void	f_删除();
	void	f_回收();
	void    f_Show(bool open);
};

C_节点基类* f_node_创建外部加载物体节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载外部加载物体节点(S_设备环境& ctx, FILE* f);
void f_node_保存外部加载物体节点(C_节点基类* n, FILE* f);



class API_EXPORT C_加载模型节点 : public C_节点基类 {

public:
	C_加载模型节点(S_设备环境& ctx);
	~C_加载模型节点();

	S_Props m_文件类型;
	S_Props m_平滑法线;
	bool		f_update();
	std::string	DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建加载模型节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载加载模型节点(S_设备环境& ctx, FILE* f);
void f_node_保存加载模型节点(C_节点基类* n, FILE* f);




class API_EXPORT C_物体对称节点 : public C_节点基类 {
	S_OBArray* m_对称复制的物体;
	bool m_头次加载;
public:
	C_物体对称节点(S_设备环境& ctx);
	~C_物体对称节点();

	S_Props m_对称轴;
	S_Props m_转换后类型;

	bool f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建物体对称节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载物体对称节点(S_设备环境& ctx, FILE* f);
void		f_node_保存物体对称节点(C_节点基类* n, FILE* f);



class API_EXPORT C_取物体材质节点 : public C_节点基类 {
public:
	C_取物体材质节点(S_设备环境& ctx);
	~C_取物体材质节点();
	bool f_update();
};

C_节点基类* f_node_创建取物体材质节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载取物体材质节点(S_设备环境& ctx, FILE* f);
void		f_node_保存取物体材质节点(C_节点基类* n, FILE* f);




class API_EXPORT C_选择物体节点 : public C_节点基类 {
	std::vector<std::u16string> m_物体名称;
public:
	C_选择物体节点(S_设备环境& ctx);
	~C_选择物体节点();
	S_Props m_物体列表;
	bool    f_update();

	void    f_Show(bool open);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建选择物体节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载选择物体节点(S_设备环境& ctx, FILE* f);
void		f_node_保存选择物体节点(C_节点基类* n, FILE* f);



class API_EXPORT C_设置物体中心节点 : public C_节点基类 {
	std::vector<std::wstring> m_物体名称;
public:
	C_设置物体中心节点(S_设备环境& ctx);
	~C_设置物体中心节点();

	S_Props m_中心方式;
	S_Props m_中心位置;
	S_Props m_复制物体;
	bool    f_update();

	//void    f_Show(bool open);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建设置物体质心节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载设置物体质心节点(S_设备环境& ctx, FILE* f);
void		f_node_保存设置物体质心节点(C_节点基类* n, FILE* f);



class API_EXPORT C_设置物体法线节点 : public C_节点基类 {
	//std::vector<std::wstring> m_物体名称;
public:
	C_设置物体法线节点(S_设备环境& ctx);
	~C_设置物体法线节点();

	S_Props m_法线类型;
	//S_Props m_中心位置;
	S_Props m_复制物体;
	bool    f_update();

	//void    f_Show(bool open);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建设置物体法线节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载设置物体法线节点(S_设备环境& ctx, FILE* f);
void		f_node_保存设置物体法线节点(C_节点基类* n, FILE* f);



class API_EXPORT C_设置物体绘制模式节点 : public C_节点基类 {
	//std::vector<std::wstring> m_物体名称;
public:
	C_设置物体绘制模式节点(S_设备环境& ctx);
	~C_设置物体绘制模式节点();

	S_Props m_绘制类型;
	//S_Props m_中心位置;
	//S_Props m_复制物体;
	bool    f_update();

	//void    f_Show(bool open);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建设置物体绘制模式节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载设置物体绘制模式节点(S_设备环境& ctx, FILE* f);
void		f_node_保存设置物体绘制模式节点(C_节点基类* n, FILE* f);


















